Polymorphism in Java

Polymorphism in real world sanario

• A person can have multiple characteristics at the same time. A man can be a father, a husband, and an employee all at the same time. As a result, the same person behaves differently in different situations. This is what known as polymorphism. Polymorphism is regarded as an important piller of Object-Oriented Programming.
• Polymorphism allows us to carry out a single action in multiple ways. Polymorphism, in other words, allows you to define one interface and have multiple implementations. The word "poly" means "many," and "morphs" means "forms," so it means multiple forms.

Java polymorphism example

 // Java polymorphism example  

class GrandParent {
    void print() {
    System.out.println("Hi I am GrandFather");
  }
}
class Parent extends GrandParent{
  void print() {
    System.out.println("Hi I am Father");
  }
}
class Child extends Parent {
  void print() {
    System.out.println("Hi I am Child");
  }
}
public class Main {
  void declaration(String name) {
    System.out.println("Hi myself " + name);
  }
  void declaration(String fname, String lname) {
    System.out.println("Hi myself " + fname + " " + lname);
  }
  public static void main(String[] args) {
      // GrandParent class instance
	  System.out.println("---------------Run-time polymorphism---------------");
	  GrandParent grandParent ;
	  grandParent = new GrandParent();
	  grandParent.print();
	  grandParent = new Parent();
	  grandParent.print();
	  grandParent = new Child();
	  grandParent.print();
	    
     System.out.println("---------------Complile time ploymorphism---------------");
     Main main = new Main();
     main.declaration("Alok.");
     main.declaration("Alok", "Raja.");
  }
}

---------------Run-time polymorphism--------------- 

Hi I am GrandFather 

Hi I am Father 

Hi I am Child 

---------------Complile time ploymorphism--------------- 

Hi myself Alok. 

Hi myself Alok Raja. 

Types of Polymorphism in java

• In Java, there are 2 different types of Polymorphism that can be used:
  • Compile time Polymorphism
  • Runtime Polymorphism
• To perform Polymorphism in Java we have two different methods:
  • Method Overloading
  • Method Overriding

1.What is Method Overloading

Method overloading is the process of creating multiple methods with the same name in the same class, each of which works differently. Method overloading is a situation when a class contains multiple methods with the same name but having different papameter and return type.

Java program with Method Overloading

 // Java program with method overloading  

class Product {
    int Multiply(int p, int q){  
     return p * q;
  }

  float Multiply(float p, float q){   
	  return p * q;
  }
}
class Overloading {
 public static void main(String[] args){
    Product product=new Product();
     System.out.println(product.Multiply(2, 4));
     System.out.println(product.Multiply(5.2f, 6.3f));
 }
}

8 

32.76 

2.What is Method Overriding

Method overriding occurs when a subclass or child class declares the same method as the parent class.

Java program with Method Overriding

 // Java program with Method Overriding 

class Vehicle{  
    void run(){
	 System.out.println("Vehicle is moving");
   }  
}  	
class Bike extends Vehicle{  
  void run(){
	 System.out.println("Bike is running safely");
  }    
  public static void main(String args[]){  
    Bike obj = new Bike();
      obj.run();
  }  
} 

Bike is running safely 

What is Compile time Polymorphism

Compile Time Polymorphism Static Polymorphism is another name for it in Java. Furthermore, the method call is resolved at compile time. Method Overloading is used to achieve compile-time polymorphism. Operator Overloading can also be used to achieve this type of polymorphism. However Java does not support Operator Overloading.

Method overloading does when a class has multiple methods with the same name, but the number, types, and order of parameters, as well as the return type, different. Java allows users to use the same name for multiple functions as long as they can be distinguished by the type and number of parameters.

Java program using Compile time Polymorphism

 // Java program  using Compile time Polymorphism 

class Product {
    void Multiply(int p, int q){  
    System.out.println("Addition of two numbers : " +(p+q)); 
  }
  void Multiply(int p, int q,int r){   
  	System.out.println("Addition of three numbers : " +(p+q+r)); 
  }
}
class Overloading {
 public static void main(String[] args){
	 Product product=new Product();
     product.Multiply(2, 4);
     product.Multiply(10, 20,30);
 }
}

Addition of two numbers : 6 

Addition of three numbers : 60 

The sum() method in this programme is overloaded with two types via different parameters.This is the baisc idea behind compile-time polymorphism in Java, where we can perform different operations by calling multiple methods with the same name.

What is Runtime Polymorphism in Java?

• Java's runtime polymorphism is also referred to as dynamic binding or dynamic method dispatch. Java's runtime polymorphism resolves the call to an overridden method dynamically during runtime as opposed to compile-time. Runtime polymorphism can be achived through Method Overriding.
• Method Overriding occurs when a child or subclass has a method with the same name, inputs, and output as the parent or superclass, that method overrides the superclass method. This is known as overriding. In simple terms, a method in the base class is said to be overridden if the subclass gives its definition to a method already present in the superclass.
• It should be noted that data members cannot be used to achieve runtime polymorphism; only functions can.
• Utilizing a superclass reference variable is how overriding is accomplished. The object that the reference variable is referring to determines which method needs to be called. Upcasting is another name for this. 

Java program Runtime Polymorphism

 // Java program Runtime Polymorphism 

class car 
{ 
    int speedlimit = 25; 
    void run() { 
    System.out.println("Runnning at 25 kmph speed"); 
    } 
} 
class Nano extends car 
{ 
    int speedlimit = 35; 
    void run() { 
    	  System.out.println("Runnning at 35 kmph speed"); 
    } 
    public static void main(String args[]) 
    { 
    car obj = new Nano(); 
    System.out.println(obj.speedlimit);
    obj.run();
    }
}

25   // run time polymorphism achive 

Runnning at 35 kmph speed 

Advantages of Polymorphism in Java

• Polymorphism allows the code to be reused. Classes that have been written, tested, and implemented can be reused several times. Furthermore, it saves the coder a significant amount of time. Furthermore, the code can be changed without affecting the original code.
• Multiple data values can be stored in a single variable. The value of a variable inherited from the superclass into the subclass can be altered without altering the value of that variable in the superclass or any other subclass.
• Debugging the code gets easier for the coder with fewer lines of code.